home *** CD-ROM | disk | FTP | other *** search
/ Scene Storm / Scene Storm - Volume 1.iso / coding / c / amiexpress / source / ae / code / aemci.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-18  |  16.8 KB  |  521 lines
  1. #include "bbs.h"
  2.  
  3. extern int Online_Baud;
  4. int width;
  5. extern int gnsflag;
  6. extern long Time_Last_On;
  7. extern char *ComputerTypes[];
  8. extern int System_Calls;
  9. extern char Conference_Location[];
  10. extern int LineCount;
  11. extern int NotRelative;
  12. extern int CN;
  13. //extern BOOL MCIDoor;
  14. extern int MCIViewSafe;
  15. int mciinterpret(int dtlen,char image[],BOOL returnit);
  16. int mciread(BPTR fi,char *b,int *pos,int *myeof);
  17. int mciread(BPTR fi,char *b,int *pos,int *myeof)
  18. {
  19.   register int returnval;
  20.   if(*(b+(*pos))==NULL)
  21.   {
  22.     if(*myeof) return(0);
  23.     if((returnval=FRead(fi,(APTR)b,1L,400L))<400L) *myeof=1;
  24.     *(b+returnval)='\0';
  25.     *pos=0; returnval=(int)b[*pos]; (*pos) +=1; return(returnval);
  26.   }
  27.   returnval=(int)b[*pos]; (*pos)+=1;
  28.   return(returnval);
  29. }
  30. int mcisend(char *filename)
  31. {
  32.    BPTR fi;
  33.    char image[200];
  34.    char myimage[402];
  35.    BOOL returnit=FALSE;
  36.    int stats;
  37.    UBYTE dot='|';
  38.    int dtlen;
  39.    int myeof=0;
  40.    int pos=0;
  41.    BOOL noteof;
  42.    char ch[10];
  43.    ch[1]='\0';
  44.    myimage[0]='\0';
  45.    if(!MCIViewSafe && !GET_BIT(ACS_MCI_MSG)) return(SUCCESS);
  46.    fi=Open(filename,MODE_OLDFILE); if(fi==NULL) return(SUCCESS);
  47.    while((ch[0]=mciread(fi,myimage,&pos,&myeof))!=NULL)
  48.    {
  49.       if(ch[0]==13 || ch[0]==12 || ch[0]==10) 
  50.       { 
  51.          AEPutStr("\r\n");
  52.          if(stats=CheckForPause())
  53.          {
  54.            AEPutStr("\r\n");
  55.            Close(fi);
  56.            ConPutStr(" p");
  57.            return(stats);
  58.          } 
  59.          
  60.       
  61.       if(SCheckInput())
  62.       {
  63.          stats=ReadChar(1L);
  64.          if(stats<0) 
  65.          { Close(fi);
  66.            ConPutStr(" p");
  67.            return(stats);
  68.          }
  69.       } continue;
  70.       }   
  71.       if(ch[0]=='~')
  72.       {
  73.         dtlen=0;
  74.         image[0]='\0';
  75.         while((noteof=mciread(fi,myimage,&pos,&myeof))!=NULL)
  76.         {
  77.           ch[0]=noteof;
  78.           image[dtlen]=noteof;
  79.           if(image[0]<' ') { image[1]='\0';break; }
  80.           if(dot==(UBYTE)noteof || noteof==' ') break;
  81.           if(noteof==10 || noteof==12 || noteof==13)
  82.           { ch[0]='\0'; returnit=TRUE; break;}
  83.           dtlen++;
  84.           
  85.           if(dtlen>100) { Close(fi); return(SUCCESS);}
  86.         }
  87.         if(!noteof) { Close(fi); return(SUCCESS); }
  88.         image[dtlen]='\0';
  89.         if(stats=mciinterpret(dtlen,image,returnit)!=SUCCESS)
  90.         {Close(fi); return(stats); break;}
  91.       }
  92.       else AEPutStr(ch);
  93.     } 
  94.     Close(fi);
  95. ConPutStr(" p");
  96.           
  97.   return(SUCCESS);
  98. }
  99. int mciputstr(char *str)
  100. {
  101.    register int i;
  102.    char image[200];
  103.    BOOL returnit=FALSE;
  104.    UBYTE dot='|';
  105.    int dtlen;
  106.    int stats;
  107.    BOOL noteof;
  108.    char ch[10];
  109.    i=0; 
  110.    if(!MCIViewSafe && !GET_BIT(ACS_MCI_MSG)) return(SUCCESS);
  111.    while(*(str+i)!=NULL)
  112.    {
  113.       ch[0]=*(str+i); i++;
  114.       if(ch[0]==13 || ch[0]==12 || ch[0]==10) 
  115.       { 
  116.          AEPutStr("\r\n");
  117.          if(stats=CheckForPause())
  118.          {
  119.            AEPutStr("\r\n");
  120.            return(stats);
  121.          } 
  122.          
  123.       
  124.       if(SCheckInput())
  125.       {
  126.          stats=ReadChar(1L);
  127.          if(stats<0) 
  128.          { 
  129.            return(stats);
  130.          }
  131.       } continue;
  132.       }
  133.       if(ch[0]=='~')
  134.       {
  135.         dtlen=0;
  136.         image[0]='\0';
  137.         noteof=TRUE;
  138.         while(1)
  139.         {
  140.           if(*(str+i)==NULL) { noteof=FALSE; break; }
  141.           ch[0]=*(str+i);
  142.           image[dtlen]=ch[0];
  143.           if(image[0]<' ') {  i++; image[1]='\0';break; }
  144.           if(dot==(UBYTE)ch[0] || ch[0]==' ') { i++;break; }
  145.           if(ch[0]==10 || ch[0]==12 || ch[0]==13)
  146.           { ch[0]='\0'; i++;  returnit=TRUE; break;}
  147.           dtlen++; i++;
  148.           
  149.           if(dtlen>100) { return(SUCCESS);}
  150.           if(ch[0]=='r' && dtlen==1) break;
  151.         }
  152.         if(image[0]=='r') { image[dtlen]='1'; image[0]='n'; dtlen++; }
  153.         if(!noteof) { return(SUCCESS); }
  154.         image[dtlen]='\0';
  155.         if(mciinterpret(dtlen,image,returnit)!=SUCCESS) break;
  156.        }
  157.       else {ch[1]='\0'; AEPutStr(ch);}
  158.     }
  159.   return(SUCCESS);
  160. }
  161.  
  162. int mciinterpret(int dtlen,char *image,BOOL returnit)
  163. {
  164.    char prt[200];
  165.    char tprt[200];
  166.    char confname[100]; char confloc[100];
  167.    int stats;
  168.    int width,pt,temp;
  169.     prt[0]='\0';
  170.         if(image[0]=='~')
  171.         {
  172.           strcpy(prt,image);
  173.         }else
  174.         {
  175.           width=-1;pt=0;
  176.           while(pt<dtlen)
  177.           {
  178.             switch(image[pt])
  179.             {
  180.               case 'M': sprintf(tprt,"%d",User.Messages_Posted);
  181.                         strlim(prt,tprt,width); width=-1; break;
  182.               case 'A': sprintf(tprt,"%d",User.Sec_Status);
  183.                         strlim(prt,tprt,width); width=-1; break;
  184.  
  185.               case 'S': 
  186.                 switch(image[pt+1])
  187.                 {
  188.                    case 'C':
  189.                         sprintf(tprt,"%d",System_Calls);
  190.                         strlim(prt,tprt,width); width=-1; break;
  191.  
  192.                    case 'S':
  193.                         if(!Restricted(&image[pt+3]))
  194.                         { 
  195.                           if(!MCIViewSafe && AllowedView(&image[pt+3])){
  196.                           gnsflag=0;MenuSend24(&image[pt+3],LineCount);}
  197.                           else
  198.                           if(MCIViewSafe)
  199.                           {gnsflag=0;MenuSend24(&image[pt+3],LineCount);}
  200.                         }
  201.             break;
  202.  
  203.                    case 'P':
  204.                         stats=DoPause();
  205.                         if(stats<0) return(stats);
  206.                         strcpy(prt,""); break;
  207.  
  208.                    case 'R':
  209.                         gnsflag=0;
  210.             sprintf(prt,"("\r\nDEBUGGING: %s%d",&image[pt+3],rnd(width)+1);
  211.             AEPutStr(prt);
  212. //                        if(ChecktoDisplay(prt,tprt,0,0)<0) return(NO_CARRIER); strcpy(prt,"");
  213. //            width=-1;
  214.             break;
  215.  
  216.                    default:
  217.  
  218.                         sprintf(tprt,"%d",User.Slot_Number);
  219.                         strlim(prt,tprt,width); width=-1; break;
  220.              
  221.                 } break;
  222.               case 'N': strlim(prt,User.Name,width); width=-1; break;
  223.               case '#': strlim(prt,User.PhoneNumber,width); width=-1; break;
  224.               case 'c': sprintf(prt,"%cm",image[pt+1]); break;
  225.               case 'z': sprintf(prt,"%cm",image[pt+1]); break;
  226.               case 'n': temp=image[pt+1]-'0'; if(temp<=0 || temp>9) temp=1;
  227.                         while(temp)
  228.                         { 
  229.                           AEPutStr("\r\n");
  230.                           if(stats=CheckForPause())
  231.                           {
  232.                             AEPutStr("\r\n");
  233.                             return(stats);
  234.                           } temp--; 
  235.                         }
  236.                         strcpy(prt,"");
  237.                         break;
  238.               case 'T':
  239.                    switch(image[pt+1])
  240.                    {
  241.                      case 'C': sprintf(tprt,"%u",User.Times_Called);
  242.                                strlim(prt,tprt,width); width=-1; break;
  243.                      case 'L': sprintf(tprt,"%ld",User.Time_Limit/60L);
  244.                                strlim(prt,tprt,width); width=-1; break;
  245.                      case 'R': sprintf(tprt,"%ld",Time_limit/60L);
  246.                                strlim(prt,tprt,width); width=-1; break;
  247.                     } break;
  248.               case 'C':
  249.                    switch(image[pt+1])
  250.                    {
  251.                      case 'A': strlim(prt,User.Conference_Access,width); width=-1; break;
  252.                      case 'R': strcpy(prt,""); 
  253.                                if(image[pt+2]!='\0' && image[pt+3]!='\0')
  254.                                strcpy(prt,&image[pt+3]);prt[0]=HtKey(prt);
  255.                               AEPutStr("\r\n");
  256.                                LineCount=0;
  257.                              strcpy(prt,""); break;
  258.                      case 'E': strcpy(prt,"CE"); break;
  259.                      case 'D': strcpy(prt,"CD"); break;
  260.                      case 'T': 
  261.                                strcpy(tprt,GetTheTime(NULL));
  262.                                strlim(prt,tprt,width); width=-1; break;
  263.                      case 'C': 
  264.                                
  265.                                strcpy(prt,&image[pt+3]);
  266.                                if(MCIViewSafe)
  267.                                {
  268.                                   sprintf(tprt,"%sCommands/SysCmd/",Cmds->BBSLoc);
  269.                                   if(!CustomCommand(tprt,prt,1))
  270.                                   {
  271.                                     sprintf(tprt,"%sCommands/BBSCmd/",Cmds->BBSLoc);
  272.                                     if(!CustomCommand(tprt,prt,1))
  273.                                     {
  274.                                       sprintf(tprt,"%sCommands/conf%dCmd/",Cmds->BBSLoc,CN);
  275.                                       CustomCommand(tprt,prt,1);
  276.                                     }
  277.                                   }
  278.                                }
  279.                                else
  280.                                {
  281.                                     sprintf(tprt,"%sCommands/BBSCmd/",Cmds->BBSLoc);
  282.                                     if(!CustomCommand(tprt,prt,0))
  283.                                     {
  284.                                       sprintf(tprt,"%sCommands/conf%dcmd/",Cmds->BBSLoc,CN);
  285.                                       CustomCommand(tprt,prt,0);
  286.                                     }
  287.                                }
  288.                                strcpy(prt,"");
  289.                                break;
  290.                      case 'L': stats = 0; width=0;if(image[pt+2]!='\0') tprt[0]=image[pt+2];
  291.                                else tprt[0]=' '; tprt[1]='\0';
  292.                                  while(stats<Boards_Are_Active)
  293.                                  {
  294.                                       
  295.                                    if(IsValidConf(stats))
  296.                                    {
  297.                                      GetConfName(confname,confloc,stats);
  298.                                      width++;
  299.                                      sprintf(prt,"                     %3d) ",width);
  300.                                      AEPutStr(prt);
  301.                                      temp=strlen(confname);
  302.                                      while(temp<30) { AEPutStr(tprt); temp++; }
  303.                                      sprintf(prt,"%s\r\n",confname);
  304.                                      AEPutStr(prt);
  305.                                    }
  306.                                    stats++;
  307.                                  }
  308.                                  GetConfName(confname,confloc,CN-1);
  309.                                strcpy(prt,""); width = -1;break;
  310.                    }
  311.                    break;
  312.               case 'D': 
  313.                    switch(image[pt+1])
  314.                    {
  315.                      case 'T': strcpy(tprt,GetTheDate(NULL));strlim(prt,tprt,width); width=-1; break;
  316.                      case 'B': sprintf(tprt,"%ld",User.Bytes_Download);
  317.                                strlim(prt,tprt,width); width=-1; break;
  318.                      default: strcpy(prt,""); break;
  319.                    }break;
  320.                case 'F':
  321.                  switch(image[pt+1])
  322.                  {
  323.                    case 'U': sprintf(tprt,"%d",User.Uploads);
  324.                              strlim(prt,tprt,width); width=-1; break;
  325.                    case 'D': sprintf(tprt,"%d",User.Downloads);
  326.                              strlim(prt,tprt,width); width=-1; break;
  327.                    default: strcpy(prt,"F"); break;
  328.                  }break;
  329.                case 'H':
  330.                  switch(image[pt+1])
  331.                  {
  332.                    case 'W': strlim(prt,ComputerTypes[User.Sec_Bulletin],width); width=-1; break;
  333.                  }break;
  334.                case 'L':
  335.                  switch(image[pt+1])
  336.                  {
  337.                    case 'C':
  338.                       sprintf(tprt,"%s",ctime(&Time_Last_On));
  339.                       tprt[strlen(tprt)-1]='\0';
  340.                       strlim(prt,tprt,width); width=-1;
  341.                       break;
  342.                    case 'G':
  343.                       sprintf(tprt,"%d",Cmds->AcLvl[LVL_NODE_NUMBER]);
  344.                       strlim(prt,tprt,width); width=-1; break;
  345.                    
  346.                  }break;
  347.                case 'U':
  348.                  switch(image[pt+1])
  349.                  {
  350.                    case 'L': strlim(prt,User.Location,width); width=-1; break;
  351.                    case 'B': sprintf(tprt,"%ld",User.Bytes_Upload);
  352.                              strlim(prt,tprt,width); width=-1; break;
  353.                  } break;
  354.                case 'B':
  355.                  switch(image[pt+1])
  356.                  {
  357.                    case 'D': sprintf(tprt,"%ld",User.Daily_Bytes_Limit);
  358.                              strlim(prt,tprt,width); width=-1; break;
  359.                    case 'R': sprintf(tprt,"%d",Online_Baud);
  360.                              strlim(prt,tprt,width); width=-1; break;
  361.                    default: strcpy(prt,"B"); break;
  362.                  }break;
  363.                case 'W': if(width<0) width=1;
  364.                    Delay((LONG)width); width=-1; break;
  365.                case 'b':
  366.                  sprintf(prt,"%cm",image[pt+1]); break;
  367.                case 'h':
  368.                  while(image[pt+1]!='0')
  369.                  {
  370.                     AEPutStr("\b \b"); image[pt+1] -=1;
  371.                  } break;
  372.                case 'q':
  373.                  strcpy(prt,""); break;
  374.                case 'x': temp=atoi(&image[pt+1]);
  375.                          sprintf(tprt,"%dH",temp);
  376.                          strcpy(prt,tprt); break;
  377.                case 'y': temp=atoi(&image[pt+1]);
  378.                          sprintf(tprt,"%d;",temp);
  379.                          strcpy(prt,tprt); break;
  380.   
  381.                case 'f':
  382.                  temp=image[pt+1]-'0';
  383.                  if(temp==0) strcpy(prt,"\x9B\x48");
  384.                else strcpy(prt,"\x0c"); break;
  385.                case '0':
  386.                case '1':
  387.                case '2':
  388.                case '3':
  389.                case '4':
  390.                case '5':
  391.                case '6':
  392.                case '7':
  393.                case '8':
  394.                case '9':
  395.                  if(pt==0)
  396.                  {
  397.                     width=atoi(image); if(width>80) width=80;
  398.                     while(image[pt]>='0' && image[pt]<='9') pt++;break;
  399.                  }
  400.                  
  401.                  break; 
  402.               default: strcpy(prt,image);
  403.                }
  404.             if(width==-1)break;
  405.            }
  406.          }        
  407.         AEPutStr(prt);
  408.         if(returnit==TRUE)
  409.         { AEPutStr("\r\n");
  410.          if(stats=CheckForPause())
  411.          {
  412.            AEPutStr("\r\n");
  413.            return(stats);
  414.          }
  415.          returnit=FALSE;
  416.        } 
  417.   return(SUCCESS);
  418. }
  419. int Restricted(char *str)
  420. {
  421.    BPTR  FLock;
  422.    char image[200];
  423.    int bad=TRUE;
  424.    struct FileInfoBlock *FBlock;
  425.    if((FLock=Lock(str,ACCESS_READ))!=0)
  426.    {
  427.      if((FBlock=(struct FileInfoBlock *)AllocDosObject(DOS_FIB,NULL)) == NULL)
  428.      { 
  429.        AEPutStr("\r\nCan't allocate memory to lock file!!\r\n"); bad=TRUE; 
  430.      }
  431.      else 
  432.      { 
  433.        if((Examine(FLock,FBlock))==0)
  434.        {  
  435.          AEPutStr("\r\nCan't get informations from file.\r\n"); 
  436.          bad=TRUE;  
  437.        }
  438.        else
  439.        { 
  440.      
  441.          if(!strnicmp(FBlock->fib_Comment,"Restricted",10))
  442.          { 
  443.            AEPutStr("\r\n "); AEPutStr(str); 
  444.            AEPutStr("\r\n >>Restricted File<< Updating CallersLog\r\n");
  445.            sprintf(image,"\tAttempt to examine RESTRICTED file [%.100s]\n",str);
  446.            CallersLog(image);
  447.            bad=TRUE;
  448.          }
  449.          else  
  450.          {  
  451.            bad=FALSE;//!AllowedView(FBlock->fib_Comment);  
  452.          }
  453.        }
  454.        FreeDosObject(DOS_FIB,FBlock);
  455.     }
  456.     UnLock(FLock);
  457.    }
  458.     return(bad);
  459. }
  460. int AllowedView(char *str)
  461. {
  462.    BPTR  FLock;
  463.    char image[200];
  464.    struct FileInfoBlock *FBlock;
  465.    if((FLock=Lock(str,ACCESS_READ))!=0)
  466.    {
  467.      if((FBlock=(struct FileInfoBlock *)AllocDosObject(DOS_FIB,NULL))==NULL)
  468.      { 
  469.        AEPutStr("\r\nCan't allocate memory to lock file!!\r\n"); 
  470.      }
  471.      else 
  472.      { 
  473.        if((Examine(FLock,FBlock))==0)
  474.        {  
  475.          AEPutStr("\r\nCan't get informations from file.\r\n"); 
  476.            
  477.        }
  478.        else
  479.        { 
  480.          if(!strnicmp(FBlock->fib_Comment,"Allowed",7))
  481.          {
  482.            FreeDosObject(DOS_FIB,FBlock);
  483.            UnLock(FLock);return(TRUE);
  484.          }
  485.            if(!strwild(FBlock->fib_Comment,"{~~~}Allowed",'~',12))
  486.            { 
  487.              strcpy(image,FBlock->fib_Comment);
  488.              if(atoi(&image[1])<=User.Sec_Status)
  489.              {
  490.                FreeDosObject(DOS_FIB,FBlock);
  491.                 UnLock(FLock);return(TRUE);
  492.              }
  493.            }
  494.          
  495.        }
  496.        FreeDosObject(DOS_FIB,FBlock);
  497.  
  498.     }
  499.     UnLock(FLock);
  500.    }
  501.     return(FALSE);
  502. }
  503. /*
  504. int strwild(char *str,char *str1,char wild,int len)
  505. {
  506.    register int i=0;
  507.    char im1[200];char im2[200];
  508.    strcpy(im1,str);
  509.    strcpy(im2,str1);
  510.    strupr(im1);strupr(im2);
  511.    if(im1[0]=='\0') return(1);
  512.    while(im1[i] && i<len)
  513.    {
  514.      if(im2[i]=='\0') return(1);
  515.      if(im2[i]==wild ) { i++; continue; }
  516.      if(im1[i]!=im2[i]) return(1);
  517.      i++;
  518.    }
  519.    return(0);
  520. }
  521. */